/**
 * 配置管理模块
 * 负责管理系统配置、字段映射规则、业务规则参数等
 */

// 全局配置对象
window.AppConfig = {
    // API 基础配置
    api: {
        baseUrl: '/api',
        timeout: 30000,
        headers: {
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        },
        endpoints: {
            config: '/api/config',
            conversionTypes: '/api/config/conversion-types',
            fieldMappings: '/api/config/field-mappings',
            businessRules: '/api/config/business-rules',
            templatePaths: '/api/config/template-paths',
            fileUpload: '/api/fileupload/single',
            chunkUpload: '/api/fileupload/chunk',
            conversion: '/api/dataconversion/start',
            conversionProgress: '/api/dataconversion/progress',
            conversionResult: '/api/dataconversion/result',
            // 移除了已不再需要的字段映射和验证相关的端点
            // validateMapping: '/api/dataconversion/validate-mapping',
            // previewRules: '/api/dataconversion/preview-rules',
            // fieldMappings: '/api/config/field-mappings',
            downloadTemplate: '/api/download/template',
            downloadResult: '/api/download/result',
            downloadBatch: '/api/download/batch'
        }
    },

    // 文件上传配置
    upload: {
        maxFileSize: 100 * 1024 * 1024, // 100MB
        chunkSize: 5 * 1024 * 1024,     // 5MB 分片大小
        allowedTypes: ['.xlsx'], // 仅支持xlsx格式
        maxConcurrentUploads: 3
    },

    // 转换类型配置
    conversionTypes: {
        'yinhai-to-ph1': {
            name: '银海品项转PH1',
            description: '银海品项格式转换为PH1系统数据',
            sourceFormat: '银海品项',
            targetFormat: 'PH1',
            templatePath: 'templates/品项批量导入模板.xlsx',
            rules: ['字段映射', '编码标准化', '格式适配']
        },
        'clinic-log': {
            name: '门诊日志转换',
            description: '支持任意表格导入的门诊日志转换',
            sourceFormat: '任意格式',
            targetFormat: '标准门诊日志',
            templatePath: 'templates/门诊日志.xlsx',
            rules: ['动态字段识别', '数据清洗', '格式标准化']
        },
        'ph3-remote': {
            name: 'PH3异地数据转换',
            description: 'PH3异地就医数据转换处理',
            sourceFormat: 'PH3异地',
            targetFormat: 'JY结算记录',
            templatePath: 'templates/PH3数据生成.xlsx',
            rules: ['异地规则', '结算逻辑', '数据同步']
        },
        'data-split': {
            name: '数据拆分',
            description: '将大型Excel文件拆分为多个小文件',
            sourceFormat: 'Excel文件',
            targetFormat: '多个拆分文件',
            templatePath: '',
            rules: ['按行数拆分', '保留表头', '压缩包输出']
        }
    },



    // 业务规则参数配置
    businessRules: {
        // PH3导入的11项校验规则
        ph3ValidationRules: {
            '厂家为空填无': {
                enabled: true,
                field: '生产厂商',
                rule: 'isEmpty',
                defaultValue: '无',
                description: '当生产厂商字段为空时，自动填入"无"'
            },
            '拆零数量逻辑校验': {
                enabled: true,
                field: '拆零数量',
                rule: 'numeric',
                min: 1,
                max: 9999,
                description: '拆零数量必须为1-9999之间的整数'
            },
            '规格特殊字符替换': {
                enabled: true,
                field: '商品规格',
                rule: 'replace',
                replacements: {
                    'X': '*',
                    'x': '*',
                    '×': '*'
                },
                description: '将规格中的X、x、×替换为*'
            },
            '医保码类型判断': {
                enabled: true,
                field: '国家药监编码',
                rule: 'pattern',
                patterns: {
                    'T': '中药',
                    'C': '耗材',
                    'H': '西药'
                },
                description: '根据编码首字母判断药品类型'
            },
            '销售状态规范化': {
                enabled: true,
                field: '销售状态',
                rule: 'normalize',
                mappings: {
                    '售完即停': '启动',
                    '正常销售': '启动',
                    '暂停销售': '停用',
                    '下架': '停用'
                },
                description: '标准化销售状态字段值'
            }
        },

        // 特殊字符替换规则
        characterReplacements: {
            'X': '*',
            'x': '*',
            '×': '*',
            '/': '*',
            '\\': '*',
            '|': '*',
            '"': '\'',
            '<': '(',
            '>': ')'
        },

        // 拆零数量阈值配置
        splitQuantityRules: {
            'default': {
                min: 1,
                max: 9999,
                unit: '最小包装'
            },
            '中药': {
                min: 1,
                max: 500,
                unit: '克'
            },
            '耗材': {
                min: 1,
                max: 10000,
                unit: '个'
            }
        },

        // 数据类型转换规则
        typeConversionRules: {
            'ph2StatusConversion': {
                '0': '未匹配',
                '1': '已匹配',
                '2': '需确认'
            },
            'yinhaiTypeConversion': {
                '0': '1',  // 银海品项转换：0→1
                '2': '2'   // 银海品项转换：2→2
            }
        }
    },

    // 路径配置集
    templatePaths: {
        'ph1Template': 'templates/品项批量导入模板.xlsx',
        'ph2Template': 'templates/PH2数据模板.xlsx',
        'ph3Template': 'templates/PH3数据生成.xlsx',
        'yinhaiTemplate': 'templates/银海品项模板.xlsx',
        'clinicLogTemplate': 'templates/门诊日志.xlsx',
        'jySettlementTemplate': 'templates/JY结算主记录.xlsx',
        'downloadPath': 'downloads/',
        'uploadPath': 'uploads/',
        'tempPath': 'temp/'
    },

    // 前端规则配置（轻量级规则）
    frontendRules: {
        // 文件解析规则
        fileParsingRules: {
            'excel': {
                maxRows: 100000,
                maxColumns: 100,
                supportedSheets: ['数据', 'Sheet1', 'data'],
                encoding: 'utf-8'
            }
        },

        // 字段匹配可视化配置
        fieldMatchingConfig: {
            autoMatchThreshold: 0.8,  // 自动匹配相似度阈值
            highlightMatched: true,
            showMappingArrows: true,
            enableDragDrop: true
        },

        // 纯数字转文本配置（Bootstrap Table cellFormatter）
        numberToTextConfig: {
            statusCodes: {
                '0': '未匹配',
                '1': '已匹配',
                '2': '需确认'
            },
            typeCodes: {
                '1': '西药',
                '2': '中药',
                '3': '耗材'
            }
        },

        // 表格渲染配置
        tableRenderConfig: {
            pageSize: 50,
            showPagination: true,
            showSearch: true,
            showColumns: true,
            showRefresh: true,
            showExport: true,
            striped: true,
            hover: true,
            responsive: true
        }
    },

    // 错误消息配置
    errorMessages: {
        'FILE_TOO_LARGE': '文件大小超过限制（最大100MB）',
        'INVALID_FILE_TYPE': '不支持的文件类型',
        'UPLOAD_FAILED': '文件上传失败，请重试',
        'MAPPING_REQUIRED': '请先配置字段映射',
        'CONVERSION_FAILED': '数据转换失败',
        'NETWORK_ERROR': '网络连接错误',
        'SERVER_ERROR': '服务器错误',
        'VALIDATION_FAILED': '数据验证失败',
        'CONFIG_LOAD_FAILED': '配置加载失败'
    },

    // 成功消息配置
    successMessages: {
        'FILE_UPLOADED': '文件上传成功',
        'MAPPING_SAVED': '字段映射保存成功',
        'CONVERSION_COMPLETED': '数据转换完成',
        'CONFIG_SAVED': '配置保存成功',
        'DOWNLOAD_READY': '文件已准备就绪，可以下载'
    }
};

/**
 * 配置管理器类
 */
class ConfigManager {
    constructor() {
        this.config = window.AppConfig;
        this.cache = new Map();
        this.cacheExpiry = 24 * 60 * 60 * 1000; // 24小时缓存
    }

    /**
     * 获取配置项
     * @param {string} path - 配置路径，支持点号分隔
     * @param {*} defaultValue - 默认值
     * @returns {*} 配置值
     */
    get(path, defaultValue = null) {
        const keys = path.split('.');
        let current = this.config;
        
        for (const key of keys) {
            if (current && typeof current === 'object' && key in current) {
                current = current[key];
            } else {
                return defaultValue;
            }
        }
        
        return current;
    }

    /**
     * 设置配置项
     * @param {string} path - 配置路径
     * @param {*} value - 配置值
     */
    set(path, value) {
        const keys = path.split('.');
        const lastKey = keys.pop();
        let current = this.config;
        
        for (const key of keys) {
            if (!(key in current) || typeof current[key] !== 'object') {
                current[key] = {};
            }
            current = current[key];
        }
        
        current[lastKey] = value;
        this.saveToStorage();
    }

    /**
     * 获取转换类型配置
     * @param {string} type - 转换类型
     * @returns {object|null} 转换配置
     */
    getConversionConfig(type) {
        return this.get(`conversionTypes.${type}`);
    }

    /**
     * 获取字段映射配置
     * @param {string} type - 转换类型
     * @returns {object|null} 字段映射配置
     */
    getFieldMapping(type) {
        return this.get(`fieldMappings.${type}`, {});
    }

    /**
     * 获取业务规则配置
     * @param {string} ruleName - 规则名称
     * @returns {object|null} 业务规则配置
     */
    getBusinessRule(ruleName) {
        return this.get(`businessRules.${ruleName}`);
    }

    /**
     * 保存配置到本地存储
     */
    saveToStorage() {
        try {
            localStorage.setItem('appConfig', JSON.stringify(this.config));
            localStorage.setItem('configTimestamp', Date.now().toString());
        } catch (error) {
            console.warn('无法保存配置到本地存储:', error);
        }
    }

    /**
     * 从本地存储加载配置
     */
    loadFromStorage() {
        try {
            const stored = localStorage.getItem('appConfig');
            const timestamp = localStorage.getItem('configTimestamp');
            
            if (stored && timestamp) {
                const age = Date.now() - parseInt(timestamp);
                if (age < this.cacheExpiry) {
                    this.config = { ...this.config, ...JSON.parse(stored) };
                    return true;
                }
            }
        } catch (error) {
            console.warn('无法从本地存储加载配置:', error);
        }
        return false;
    }

    /**
     * 从服务器更新配置
     * @returns {Promise<boolean>} 更新是否成功
     */
    async updateFromServer() {
        try {
            const response = await fetch(`${this.get('api.baseUrl')}/config`);
            if (response.ok) {
                const serverConfig = await response.json();
                this.config = { ...this.config, ...serverConfig };
                this.saveToStorage();
                return true;
            }
        } catch (error) {
            console.warn('无法从服务器更新配置:', error);
        }
        return false;
    }

    /**
     * 验证字段映射配置
     * @param {object} mapping - 字段映射配置
     * @returns {object} 验证结果
     */
    validateMapping(mapping) {
        const result = {
            valid: true,
            errors: [],
            warnings: []
        };

        // 检查循环依赖
        const dependencies = new Map();
        for (const [source, target] of Object.entries(mapping)) {
            if (!dependencies.has(target)) {
                dependencies.set(target, []);
            }
            dependencies.get(target).push(source);
        }

        // 简单循环检测
        for (const [target, sources] of dependencies) {
            if (sources.includes(target)) {
                result.valid = false;
                result.errors.push(`字段 "${target}" 存在循环依赖`);
            }
        }

        // 检查重复映射
        const targetCounts = {};
        for (const target of Object.values(mapping)) {
            targetCounts[target] = (targetCounts[target] || 0) + 1;
        }

        for (const [target, count] of Object.entries(targetCounts)) {
            if (count > 1) {
                result.warnings.push(`目标字段 "${target}" 被多个源字段映射`);
            }
        }

        return result;
    }

    /**
     * 获取错误消息
     * @param {string} errorCode - 错误代码
     * @returns {string} 错误消息
     */
    getErrorMessage(errorCode) {
        return this.get(`errorMessages.${errorCode}`, '未知错误');
    }

    /**
     * 获取成功消息
     * @param {string} successCode - 成功代码
     * @returns {string} 成功消息
     */
    getSuccessMessage(successCode) {
        return this.get(`successMessages.${successCode}`, '操作成功');
    }
}

// 创建全局配置管理器实例
window.configManager = new ConfigManager();

// 页面加载时初始化配置
document.addEventListener('DOMContentLoaded', function() {
    // 尝试从本地存储加载配置
    if (!window.configManager.loadFromStorage()) {
        // 如果本地存储没有有效配置，尝试从服务器更新
        window.configManager.updateFromServer();
    }
});